var _n41;
var cc__extends = __extends;
var cc__decorate = __decorate;
var cc__importDefault = __importDefault;
Object.defineProperty(exports, "__esModule", {
  value: true
});
var $1$ResourceLoader = require("ResourceLoader");
var s = cc__importDefault($1$ResourceLoader);
var $1$ScrewGameConfig = require("ScrewGameConfig");
var c = cc__importDefault($1$ScrewGameConfig);
var cc__decorator = cc._decorator;
var ccp_ccclass = cc__decorator.ccclass;
var ccp_property = cc__decorator.property;
var def_Target = function (t) {
  function _ctor() {
    // 假设该代码片段是某个类的方法的一部分，其他逻辑未给出。
    let optimizedInstance = null !== t && t.apply(this, arguments) || this;

    // 定义属性
    optimizedInstance.type = -1;         // 类型设置为-1
    optimizedInstance.posIndex = -1;     // 位置索引初始化为-1
    optimizedInstance.targetCount = 3;    // 目标计数设置为3
    optimizedInstance.sprite = null;      // 精灵初始值为null
    optimizedInstance.capSpr = null;      // 顶部精灵初始值为null
    optimizedInstance.holeNode = null;    // 孔节点初始值为null
    optimizedInstance.state = 0;          // 状态初始化为0

    // 返回优化后的实例
    return optimizedInstance;

  }
  cc__extends(_ctor, t);
  _ctor.prototype.onLoad = function () {
    this.type = -1;
  };
  _ctor.prototype.sub = function () {
    // 检查目标计数是否小于或等于0
    if (this.targetCount <= 0) {
      return null;  // 返回null表示没有可用的目标
    }

    // 递减目标计数
    this.targetCount--;

    // 获取对应的孔节点子项
    const holeChild = this.holeNode.children[this.targetCount];

    // 激活该子项
    holeChild.active = true;

    // 执行目标动画
    this.targetAnmation(holeChild);

    // 返回激活的目标子项
    return holeChild;

  };
  _ctor.prototype.targetAnmation = function (t, e, o) {
    // 确保透明度的起始值和结束值已定义
    if (undefined === e) {
      e = 0;  // 设置默认透明度为0
    }
    if (undefined === o) {
      o = 255;  // 设置默认透明度为255
    }

    // 遍历子节点，从最后一个开始
    for (let index = t.children.length - 1; index >= 0; index--) {
      const child = t.children[index];  // 获取当前子节点
      child.opacity = e;    // 设置子节点的初始透明度

      // 为子节点添加渐变动画
      cc.tween(child)
        .delay(0.1 * (t.children.length - index))  // 延迟时间
        .to(0.2, { opacity: o })         // 动画效果
        .start();                                   // 开始动画
    }

  };
  _ctor.prototype.initWithType = function (t) {
    //初始化环境和状态
    const context = this;  // 当前上下文
    this.targetCount = 3;  // 目标计数设置为3
    this.type = t;         // 设定类型
    this.state = c.default.TargetState.Loading;  // 设置状态为加载中

    //遍历孔节点的子节点
    for (let i = 0; i < this.holeNode.children.length; i++) {
      const holeNode = this.holeNode.children[i];
      holeNode.active = false;  // 将当前孔节点设为非激活状态

      // 加载子节点的纹理
      const loadSprite = (index) => {
        const child = holeNode.children[index];  // 获取当前子节点
        const spriteComponent = child.getComponent(cc.Sprite);  // 获取精灵组件

        // 加载对应的纹理
        s.default.getInstance().load("Feibiao", `rope/order/${t + 1}-3`, cc.SpriteFrame).then((spriteFrame) => {
          spriteComponent.spriteFrame = spriteFrame;  // 设置精灵帧
          child.opacity = 0;  // 初始化透明度

          // 添加渐变动画
          cc.tween(child)
            .delay(0.1 * index)  // 设置延迟
            .to(0.2, { opacity: 255 })  // 渐变到完全不透明
            .start();  // 开始动画
        });
      };

      // 遍历当前孔节点的子节点
      for (let j = 0; j < holeNode.children.length; j++) {
        loadSprite(j);  // 加载精灵
      }
    }

    // 加载顶部精灵纹理
    s.default.getInstance().load("Feibiao", `rope/order/${t + 1}`, cc.SpriteFrame).then((spriteFrame) => {
      context.sprite.spriteFrame = spriteFrame;  // 设置顶部精灵帧
    });

    // 加载盖子精灵纹理
    s.default.getInstance().load("Feibiao", `rope/order/${t + 1}-2`, cc.SpriteFrame).then((spriteFrame) => {
      context.capSpr.spriteFrame = spriteFrame;  // 设置盖子精灵帧
    });

  };
  _ctor.prototype.showOne = function (t) {
    this.holeNode.children[t].active = true;
  };
  _ctor.prototype.isFinish = function () {
    return 0 === this.targetCount;
  };
  _ctor.prototype.showFinishAnimation = function (t, e) {
    const holeNodes = this.holeNode.children; // 获取所有孔节点的子节点
    const delayIncrement = t / (holeNodes.length * holeNodes[0].children.length); // 计算每个子节点的延迟时间
    let currentIndex = 0; // 当前索引初始化

    // 遍历所有孔节点
    for (let r = 0; r < holeNodes.length; r++) {
      const holeNode = holeNodes[r];

      // 定义一个函数处理子节点透明度变化
      const fadeChild = (index) => {
        const child = holeNode.children[index]; // 获取当前子节点
        child.opacity = 255; // 设置初始不透明度为255

        // 判断是否为最后一个子节点
        const isLastChild = currentIndex === holeNodes.length * holeNode.children.length - 1;

        // 执行透明度减小动画
        cc.tween(child)
          .delay(currentIndex * delayIncrement) // 设置动画延迟
          .to(0.2, { opacity: 0 }) // 渐变到透明
          .call(() => {
            if (isLastChild) {
              e(); // 如果是最后一个子节点则调用回调函数
            }
          })
          .start();

        currentIndex++; // 更新当前索引
      };

      // 遍历当前孔节点的所有子节点
      for (let c = 0; c < holeNode.children.length; c++) {
        fadeChild(c); // 对每个子节点调用fadeChild
      }
    }
  };
  _ctor.prototype.updateView = function (t) {
    // 确保目标计数t已定义，默认值为3
    if (undefined === t) {
      t = 3;
    }
    this.targetCount = t; // 设置目标计数
    cc.log(this.targetCount); // 输出当前目标计数

    // 遍历孔节点，并根据目标计数设置其激活状态
    for (let index = 0; index < 3; index++) {
      const holeNode = this.holeNode.children[index]; // 获取当前孔节点

      // 根据目标计数决定孔节点是否激活
      if (index >= this.targetCount) {
        holeNode.active = true; // 超过目标计数时激活该节点
      } else {
        holeNode.active = false; // 否则设为非激活状态
      }
    }
  };
  cc__decorate([ccp_property(cc.Sprite)], _ctor.prototype, "sprite", undefined);
  cc__decorate([ccp_property(cc.Sprite)], _ctor.prototype, "capSpr", undefined);
  cc__decorate([ccp_property(cc.Node)], _ctor.prototype, "holeNode", undefined);
  return cc__decorate([ccp_ccclass], _ctor);
}(cc.Component);
exports.default = def_Target;